`color(RED,LIGHTGRAY);<<<<<<<<<<<<<<<<<<<<< Welcome to EnQue's InTUItion V1.10 >>>>>>>>>>>>>>>>>>>>>`color();
`tab(2);`color_default(LIGHTGRAY,BLUE);`color_keyword(YELLOW,BLUE);`color_first_char(WHITE,BLUE);

 ┌──────────────────────────────────────────────────────────────────────────┐
 │												`keyword(Introduction,/// Introduction);                                      │
 │                        `keyword(How the TUICP works,/// How the TUICP works);                               │
 │                        `keyword(The TUICP's menus,/// The TUICP's menus);                                 │
 │                        `keyword(Dialog objects,/// Dialog objects);                                    │
 │                        `keyword(Creating dialogs,[TUI1.HLP]/// Creating dialogs);                                  │
 │                        `keyword(Dialog Transfer and Menu construction,[TUI2.HLP]/// Dialog Transfer);             │
 │                        `keyword(Incorporating Dialogs into your programs,[TUI2.HLP]/// Incorporating Dialogs);          │
 │                        `keyword(The InTUItion Library,[TUI3.HLP]/// The InTUItion Library);                             │
 │												`keyword(The Online Tutorials,/// The Online Tutorials);                              │
 └──────────────────────────────────────────────────────────────────────────┘

`co(4,7);─────────────────────────────── /// Introduction ─────────────────────────────`co();

	  The TUICP (Textual User Interface Construction Program) is a programming
	tool designed to make the construction of user interfaces not only easy,
	but fun!  The TUICP, taking advantage of the power of EnQue's UltraWin
	windowing library, allows you to interactively "draw" your menus, dialog
	boxes, data-entry forms, etc.  User customizable screen size, colors,
	palettes, fonts, and more make the TUICP the most flexible screen designer
	available.

	  We at EnQue take a slightly different approach to teaching you how to
	use our tools.  Like most people, we hate to read long, complicated
	technical manuals, and find that little information is retained.  If you
	have been programming for any time at all, you know that the best way to
	learn something is to dive right in and make it work.  We take the latter
	approach with a few sophisticated aids to help.  In this way, we can keep
	our manuals relatively small, serving mainly as a function usage and
	reference guide.

	  First of all, we ship the full source code not only for our libraries,
	but for the tools as well.  This is a real rarity in this business.  We do
	this because as programmers we often run across a utility that is "almost"
	exactly what we need "if only".  For those of you who run into this, you
	can add those last few features that make it perfect for you.  In
	addition, the source provides insight into how the tools work and the more
	you know about the inner workings the more you understand how to take
	advantage of its features.  Secondly, we include several demo programs
	that illustrate how to use most of the functions in the library.  Some of
	the demos are quite large but are very modular, with a particular module
	or function demonstrating just a few features.  Last and most important,
	we have included several fully automated tutorials that take you through
	actual recorded sessions and teach you how to incorporate each dialog
	object.  A few minutes with the tutorials will save you hours of reading
	boring manuals.  You even end up with a usable dialog at the end!  If you
	get stuck while creating a dialog, context-sensitive help is only a button
	press or keystroke away.  In most cases, you will never have to use the
	manual.

`co(4,7);─────────────────────────── /// How the TUICP works ──────────────────────────`co();

	  The TUICP allows you to use the keyboard and mouse to construct your
	dialogs.  Many dialogs can exists within a single .TUI file, similar to
	project files commonly used by compilers.  InTUItion saves all the needed
	information to recreate your dialogs during runtime.  IT DOES NOT store
	wasteful screen images like many other products.  InTUItion's dialogs can
	even be modified "on-the-fly" by modifying variables within the
	controlling structures.  A header file, with a .DEF extension, containing
	defines that describe each object is saved along with the TUI and is used
	in your program so that each object can be referenced by name, not by
	number. Don't modify this file, the TUICP does this for you.

	  Dialog files can either be read in during run time or alternatively, the
	TUICP can generate "C" source code that can be compiled and linked into
	your exe file.  The advantage of loading the file is easy modification
	without recompiling (assuming the basic structure of the dialog has not
	been changed, i.e., buttons added/removed, etc.).  This method is
	recommended during program development.  In addition, you may be
	developing a program where you would like the user to have the ability to
	change the position, colors, etc. of the program's dialogs.  Linking in
	the dialogs will slightly increase the code size but eliminate the need
	for file I/O during startup.  This also prevents users from editing the
	dialogs, or worse, deleting the files.  This is recommended for final
	versions of your programs.

	  Once a dialog is loaded into memory, the InTUItion library will
	"process" all dialog commands, returning to you depending on the flags set
	for each item.  Processing the commands is done with a simple switch
	statement. InTUItion handles all the keyboard and mouse interaction.  Once
	a dialog is created and tested, the TUICP will generate a "C" source code
	shell that contains the switch statements necessary to process each
	possible event. Finishing off your program becomes a simple matter of
	writing the code for each case.  Program development time can be reduced
	by up to 90%. An excellent example is the font editor included with
	InTUItion.  The font editor took less than 20 hours to write, start to
	finish.  Without InTUItion, even using the power of UltraWin, this program
	would have taken over 100 hours.  But don't take our word on this, we're
	biased.  Try a few programs yourself and see how easy it is.

	  The TUICP will also generate a "C" source shell that allows for the
	inclusion of context-sensitive help.  A switch statement similar to the
	one above can be created with a search string into a help file, and a
	click of the right button will access the help, taking the user right to
	the proper location.  All you have to do is create the ASCII help file and
	modify the search strings if needed; the rest is automatic.

	  Internally, InTUItion stores base structures that contains the global
	parameters for the TUI and a pointer to additional structures depending on
	what objects you add to the dialog.  Each time you add an object,
	InTUItion allocates a stucture for that object and stores a pointer to it
	in the base structure.  This "base array", which is equal in size to the
	total number of objects in the TUI, is indexed by the names you specify
	for each object. The TUICP converts the names to an integer and stores
	these as defines in an ASCII .DEF include file.  Do not modify the actual
	values, although it is perfectly fine to modify the define names.  If you
	change the names, the next time you load that TUI into the TUICP, your new
	names will be used.

	  Most TUI structures contain a pointer to additional parameters an object
	may need.  For example, the button's additional parameter is the text for
	the button.  By allocated this space as needed, InTUItion can keep memory
	requirements low yet allow for large fields if needed.  You may notice
	that these pointers are "C" unions.  This is necessary because pointers
	are different sizes depending on the memory model.  In order for TUI files
	to be compatible across models, we use a union that allocates four bytes,
	the size of a pointer in large model.  If you peruse through the T.H
	header file you will see exactly what you modify when using the
	construction program!

`co(4,7);─────────────────────────────── /// Dialog objects ───────────────────────────`co();

	  InTUItion dialogs consist of a collection of buttons, strings, sliders,
	and other objects.  To create such a dialog we must first understand what
	each object is and its purpose.

 ┌──────────────────────────────────────────────────────────────────────────┐
 │                           `keyword(Text Strings,/// Text Strings);                                   │
 │                           `keyword(Boxes,/// Boxes);                                          │
 │                           `keyword(Buttons,/// Buttons);                                        │
 │                           `keyword(Check Boxes,/// Check Boxes);                                    │
 │                           `keyword(Icons,/// Icons);                                          │
 │                           `keyword(Sliders,/// Sliders);                                        │
 │                           `keyword(Entry Strings,/// Entry Strings);                                  │
 │                           `keyword(Attributes and Flags,/// Attributes and Flags);                           │
 └──────────────────────────────────────────────────────────────────────────┘

`co(15,?);/// Text Strings`co();
	  The simplest object is the text string.  This is actually a button that
	is not selectable or tabable and will not return if the user clicks on it
	or presses a hot key.  Strings are primarily used for labeling other
	objects.  Since a dialog is a memory structure, you can format your own
	data into this string and redraw it if desired.  This allows you to output
	data to a dialog as well as input data.

`co(15,?);/// Boxes`co();
	  A box is a rectangular area within the dialog that may be used by your
	program for output or to hold and group other objects, such as radio
	buttons.

`co(15,?);/// Buttons`co();
		Buttons consist of text within a box.  A button can have a different
	appearance when selected or tabbed, and can be set to behave differently
	depending on the presence of other buttons in its group.  The following
	are the flags for the different types of buttons available.

  `co(15,?);Normal`co();
  	Normal buttons act independently, having no effect on other buttons,
		even if they reside in the same box.
  `co(15,?);Radio`co();
    Radio buttons are a group of buttons within a box that are mutually
		exclusive.  If one is selected, all others are turned off.  This is
		useful where the user must select one option.  To make radio buttons,
		create a box to contain the group and make sure the radio flag is set
		for each button.  If you don't want the bounding box to show, simply
		set its color to the same as the color of the dialog, effectively
		"hiding" it.  If you have only one group of radio buttons in your
		dialog, you may simply put them in the dialog, without a grouping box,
		as the dialog itself acts as the base level box.
  `co(15,?);Deselectable Radio`co();
  	Deselectable Radio buttons are the same as above except that all
		buttons can be turned off if desired.  This is useful in the case where
		a user can select no option, or one of several.

`co(15,?);/// Check Boxes`co();
	  Check boxes are the same as buttons except for the text describing the
	check area and the check character itself.  All three styles are
	available.

`co(15,?);/// Icons`co();
	  An icon is similar to a box except that each character in the rectangle
	can be different, resulting in a rectangular image.  In addition, a second
	image can be displayed when the item is selected.

`co(15,?);/// Sliders`co();
	  Horizontal and Vertical sliders are actually the same object except for
	their orientation.  Sliders are useful when more data is available than
	will fit on the screen.  They give the user an easy way to scroll through
	information, while providing visual feedback as to the current position
	within that information.

`co(15,?);/// Entry Strings`co();
	  Entry strings are used to get data from the user.  They are the most
	versatile of all objects, in that you can use them to get a string from
	the user in virtually any format you wish.  This is useful when the user
	must input a name, number, date, time, phone number, etc.
  
`co(4,7);───────────────────────────── /// Attributes and Flags ───────────────────────`co();

		Each object has certain attributes that control its appearance and
	operation.  Here is a list of attributes and their meaning:

`co(15,?);Name`co();                - This is a text name that will be used in your program
											to reference this item. The TUICP uses this name to
											generate a define, which is then saved in the ASCII
											.DEF include file. Note that the reference in your
											code is really a number, which is the index into the
											TUI base array for the object. The defined names make
											your code much more readable while not reducing
											performance due to string references.
											Objects: All

`co(15,?);Border style`co();        - This is the border style and is only used by the
											dialog itself.  Options include, none, single line,
											double line, or heavy solid line.
											Objects: Dialog

`co(15,?);Border color`co();        - This is the border color and is only used by the
											dialog itself.
											Objects: Dialog

`co(15,?);Dialog color`co();        - This is the dialog color and is only used by the
											dialog itself.
											Objects: Dialog

`co(15,?);Style`co();               - This describes whether an object is displayed with
											a shadow.
											Objects: All except Dialog

`co(15,?);Normal color`co();        - This describes the normal color of an object.
											Objects: Text, Icon, Button, Check Box, Entry String 

`co(15,?);Normal 1st color`co();    - This describes the normal color of the character
											referenced by "first position."
											Objects: Text, Button, Check Box 

`co(15,?);Selected color`co();      - This describes the color of an object when selected.
											Objects: Icon, Button, Check Box 

`co(15,?);Selected 1st color`co();  - This describes the color of the character referenced
											by "first position" when the object is selected.
											Objects: Text, Button, Check Box 
       
`co(15,?);Tabbed color`co();        - This describes the color of a tabbed object.
                      Objects: Icon, Button, Check Box, Entry String 

`co(15,?);First position`co();      - This is the offset of the character in the string
											that will be displayed with the first color values.
											Objects: Text, Button, Check Box 

`co(15,?);Text`co();                - The text (string) for the object.
                      Objects: Text, Button, Check Box

`co(15,?);Icon image #1`co();       - The two-dimensional character array that describes an
											icon image.
											Objects: Icon

`co(15,?);Icon Image #2`co();       - The two-dimensional character array that describes a
											selected icon image.
											Objects: Icon

`co(15,?);Arrow color`co();         - The color of a slider arrow.
                      Objects: Slider

`co(15,?);Track color`co();         - The color of a slider track.
                      Objects: Slider

`co(15,?);Grab Box color`co();      - The color of a slider grab box.
                      Objects: Slider

`co(15,?);Slider Chars`co();        - The 6 characters used to draw a slider.  These are
											the left, right, up, down, track, and grab box
											characters.
											Objects: Slider

`co(15,?);Input Strings`co();       - The text, mask, and template strings needed for data
											entry. See the UltraWin documentation and demos for
											more details.
											Objects: Entry String

`co(15,?);Input Flags`co();         - The action InTUItion should take on an input string
                      before returning control to you.  You may use no
                      action or a combination of the following:
                      `co(15,?);Strip`co();          - strips the entire mask from string.
								      `co(15,?);Strip End`co();      - strips only the end of the string.
								      `co(15,?);Capitalize`co();     - converts the first character of
								                       each word to upper-case.
								      `co(15,?);Type R-to-L`co();    - causes input to be entered right-
								                       to left.  This is useful for prices
								                       in data-entry forms.
								      `co(15,?);<CR> on Full`co();   - causes the equivalent of an <Enter>
								                       key press when the last character of
								                       the field is entered.
								      `co(15,?);Clr on Key`co();     - causes the field to be cleared when
								                       the first valid character is typed.
								      See the UltraWin documentation and demos for more
											details.
											Objects: Entry String

		Each object has a set of flags that describe its operation.  Not all
	flags apply to all objects.  Here is a list of the flags and their
	meaning:

	`co(15,?);Selectable`co();    - The object can be selected.
	`co(15,?);Tabable`co();       - The object can be tabbed.
	`co(15,?);Radio`co();         - The object is a radio button/check box.
	`co(15,?);Exit Press`co();    - Returns when the mouse is over the object and a button is
	                pressed.
	`co(15,?);Exit Release`co();  - Returns when the mouse is over the object and a button is
	                depressed and then released.
	`co(15,?);Exit Over`co();     - Returns when the mouse cursor is over the object.
	`co(15,?);One Level`co();     - If control is transferred from another dialog, and the
	                object should exit, return just one level to the calling
	                dialog.
	`co(15,?);All Levels`co();    - If control is transferred from another dialog, and the
	                object should exit, return all levels through all calling
	                dialogs.
	                (See `keyword(Dialog Transfer,[TUI2.HLP]/// Dialog Transfer);)
	`co(15,?);Selected`co();      - The object is currently selected.  Check for this flag in
	                your program with the is_selected macro to determine if the
	                button is on or off.
	`co(15,?);Tabbed`co();        - The object is currently tabbed.

`co(4,7);──────────────────────────── /// The TUICP's menus ───────────────────────────`co();

	`co(15,?);The TUICP's Main Menu`co();
	`keyword(Info,/// Info [Main Menu]);  `keyword(Files,/// Files [Main Menu]);  `keyword(Dialogs,/// Dialogs [Main Menu]);  `keyword(Source,/// Source [Main Menu]);

	`co(15,?);The TUICP's Edit Menu`co();
	`keyword(Info,/// Info [Edit Menu]);  `keyword(Edit,/// Edit [Edit Menu]);  `keyword(Source,/// Source [Edit Menu]);

`co(15,?);/// Info [Main Menu]`co();
  Help             -  Displays the TUICP help index.  This is a context-
                      sensitive group of hypertexted files under our own
                      hypertext help engine, and contains all the
                      information you will need to utilize InTUItion.
  About InTUItion  -  Displays information about EnQue Software, along
                      with system free memory.

`co(15,?);/// Files [Main Menu]`co();
  TUI Params - Allows global control over colors, fonts, screen size, etc.
               This sets how the TUI will look when initialized in your
               program with init_tui.  This menu selection is active only
               when the TUI work window is on the main screen.
  New TUI    - Clears any TUI in memory and creates a new TUI.
  Load TUI   - Allows you to load an existing TUI file into memory.
  Save TUI   - Allows you to save the current TUI in memory to a file.
  Close TUI  - Closes the current TUI without saving.
  Dos Shell  - Shells out to DOS.  Type <exit> from DOS to return.
  Quit       - Quits the program.

`co(15,?);/// Dialogs [Main Menu]`co();
  Add Dialog       - Adds a new dialog to the current TUI.
  Add Menu Dialogs - Adds a number of menu dialogs to the current TUI.
  Delete Dialog    - Deletes a dialog from the current TUI.  After selecting
                     delete, move your mouse to the desired dialog and press
                     the left button.

`co(15,?);/// Source [Main Menu]`co();
  Gen Linkable TUI  - InTUItion TUI files can be either loaded at run time
     or linked in.  In order to link in a TUI, the source code needed to
     create the dialog must be generated and compiled.  This generates the
     source code shell, which can then be added to your project or make
     file, eliminating the need to distribute seperate TUI files.  Be sure
     to select a filename that will not clash with other "C" files.

`co(15,?);/// Info [Edit Menu]`co();
  Help           -  displays the TUICP help index.

`co(15,?);/// Edit [Edit Menu]`co();
  Clear          -  Clears all object from the dialog.
  Copy           -  Copies an object to the clipboard.  After selecting
                    this item, move to and click on the item to copy.
  Cut            -  Same as copy but removes the item from the dialog.
  Paste          -  Pastes the current item in the clipboard to the dialog.
                    Select this item and hold down the left button,
                    dragging the item onto the dialog.
  Bring to Top   -  Changes the order of the dialog's drawing.  For
                    instance, if a box is added over several buttons and
                    you want the button to be on top of the box, select
                    this and click on the buttons.  They will now draw
                    after the box.
  Set Tab Order  -  All objects within a dialog that have the "Tabable"
                    parameter set can be tabbed to by the user.  This
                    sets the tab order. After selecting this item, click
                    on each object in the order that you wish the tabbing
                    to proceed.  Note that this has the same effect on
                    the drawing order as Bring to Top.
  Show Clipboard -  Allows you to view the last object Copied or Cut.
  Test           -  Allows you to interactively test the dialog.  This is
                    one of the TUICP's most important features.  It allows 
                    you to actually use the dialog as the user would and
                    see the actions/colors of the dialog taking place.  It
                    also allows you to test the hotkeys, tab order, slider
                    action, transfer, and display the return values of
                    each object that has been set to "exit."
  Test with Advance is the same as Test, but uses the DO_INPUT_ADV mode,
                    useful for data-entry forms.    
  Main Menu      -  Returns to the main menu.

`co(15,?);/// Source [Edit Menu]`co();
  Gen Dialog Shell  - This will generate a "C" source code shell with all
											dialog processing hooks created.  All you have to do
											is add the code needed for each dialog action.
  Dialog & Help     - This will generate a "C" source code shell with all
											dialog processing hooks created, including
											context-sensitive calls to the hypertext help engine.
											All you have to do is add the code needed for each
											dialog action, and set the desired help search
											strings.

`co(4,7);───────────────────────── /// The Online Tutorials ───────────────────────────`co();

	  One of the quickest ways to learn about a tool is to have someone who
	knows how to use it show you.  Now while we at EnQue can't sit down with
	each and every one of you, we have given you the next best thing. Included
	on the disk are a number of .TUT files.  These are recorded sesssions of
	one of us putting the TUICP through its paces.  We use a popup comment box
	throughout the sessions to "chat" with you during each phase of TUI
	construction.
	
  To play back a .TUT file, just type 

  TUICP -pFILENAME.TUT
  
  from the command line, then sit back, relax, and let us show you how to
  become proficient in no time at all!

